{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af017e5c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:45.133959Z",
     "iopub.status.busy": "2025-11-03T08:18:45.133442Z",
     "iopub.status.idle": "2025-11-03T08:18:46.494260Z",
     "shell.execute_reply": "2025-11-03T08:18:46.493738Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "\n",
    "\n",
    "transform = transforms.ToTensor()\n",
    "\n",
    "# 下载数据集\n",
    "train_dataset = datasets.MNIST(root=\"data\", train=True, download=True, transform=transform)\n",
    "test_dataset = datasets.MNIST(root=\"data\", train=False, download=True, transform=transform)\n",
    "\n",
    "# 把图像拉直成一行\n",
    "train_images = train_dataset.data.numpy().reshape(-1, 28 * 28).astype(np.float32) / 255.0\n",
    "test_images = test_dataset.data.numpy().reshape(-1, 28 * 28).astype(np.float32) / 255.0\n",
    "\n",
    "# 标签拿出来作为 numpy 数组\n",
    "train_labels = train_dataset.targets.numpy()\n",
    "test_labels = test_dataset.targets.numpy()\n",
    "\n",
    "# 保存一些公共参数\n",
    "input_dim = 28 * 28\n",
    "num_classes = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ce74c3fb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:46.495669Z",
     "iopub.status.busy": "2025-11-03T08:18:46.495519Z",
     "iopub.status.idle": "2025-11-03T08:18:46.952305Z",
     "shell.execute_reply": "2025-11-03T08:18:46.952094Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "单层感知机 第 1 轮，训练准确率: 0.8941166666666667 测试准确率: 0.9007\n",
      "单层感知机 第 2 轮，训练准确率: 0.90285 测试准确率: 0.9097\n",
      "单层感知机 第 3 轮，训练准确率: 0.9089833333333334 测试准确率: 0.9122\n",
      "单层感知机 第 4 轮，训练准确率: 0.9119166666666667 测试准确率: 0.9158\n",
      "单层感知机 第 5 轮，训练准确率: 0.9142333333333333 测试准确率: 0.9182\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "单层感知机 第 6 轮，训练准确率: 0.9159166666666667 测试准确率: 0.9177\n",
      "单层感知机 第 7 轮，训练准确率: 0.9161666666666667 测试准确率: 0.918\n",
      "单层感知机 第 8 轮，训练准确率: 0.9181166666666667 测试准确率: 0.9199\n",
      "单层感知机 第 9 轮，训练准确率: 0.91985 测试准确率: 0.9205\n",
      "单层感知机 第 10 轮，训练准确率: 0.9201166666666667 测试准确率: 0.9206\n"
     ]
    }
   ],
   "source": [
    "# 单层感知机：只有输入层到输出层\n",
    "np.random.seed(0)\n",
    "W1 = (np.random.randn(input_dim, num_classes) * 0.01).astype(np.float32)\n",
    "b1 = np.zeros(num_classes, dtype=np.float32)\n",
    "\n",
    "learning_rate = 0.1\n",
    "epochs = 10\n",
    "batch_size = 128\n",
    "\n",
    "single_train_history = []\n",
    "single_test_history = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    index_array = np.arange(train_images.shape[0])\n",
    "    np.random.shuffle(index_array)\n",
    "    for start in range(0, train_images.shape[0], batch_size):\n",
    "        batch_index = index_array[start:start + batch_size]\n",
    "        x_batch = train_images[batch_index]\n",
    "        y_batch = train_labels[batch_index]\n",
    "        z = np.dot(x_batch, W1) + b1\n",
    "        z = z - np.max(z, axis=1, keepdims=True)\n",
    "        exp_z = np.exp(z)\n",
    "        probs = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n",
    "        one_hot = np.zeros_like(probs)\n",
    "        one_hot[np.arange(one_hot.shape[0]), y_batch] = 1\n",
    "        grad_output = (probs - one_hot) / one_hot.shape[0]\n",
    "        grad_W1 = np.dot(x_batch.T, grad_output)\n",
    "        grad_b1 = grad_output.sum(axis=0)\n",
    "        W1 = W1 - learning_rate * grad_W1\n",
    "        b1 = b1 - learning_rate * grad_b1\n",
    "    train_logits = np.dot(train_images, W1) + b1\n",
    "    train_preds = np.argmax(train_logits, axis=1)\n",
    "    train_acc = (train_preds == train_labels).mean()\n",
    "    test_logits = np.dot(test_images, W1) + b1\n",
    "    test_preds = np.argmax(test_logits, axis=1)\n",
    "    test_acc = (test_preds == test_labels).mean()\n",
    "    single_train_history.append(float(train_acc))\n",
    "    single_test_history.append(float(test_acc))\n",
    "    print(\"单层感知机 第\", epoch + 1, \"轮，训练准确率:\", float(train_acc), \"测试准确率:\", float(test_acc))\n",
    "\n",
    "linear_train_acc = single_train_history[-1]\n",
    "linear_test_acc = single_test_history[-1]\n",
    "linear_test_preds = test_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "95e7990a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:46.953401Z",
     "iopub.status.busy": "2025-11-03T08:18:46.953325Z",
     "iopub.status.idle": "2025-11-03T08:18:47.983759Z",
     "shell.execute_reply": "2025-11-03T08:18:47.983540Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两层感知机 第 1 轮，训练准确率: 0.9011666666666667 测试准确率: 0.9071\n",
      "两层感知机 第 2 轮，训练准确率: 0.9192833333333333 测试准确率: 0.9225\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两层感知机 第 3 轮，训练准确率: 0.9331333333333334 测试准确率: 0.9326\n",
      "两层感知机 第 4 轮，训练准确率: 0.9404666666666667 测试准确率: 0.9402\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两层感知机 第 5 轮，训练准确率: 0.9503166666666667 测试准确率: 0.9488\n",
      "两层感知机 第 6 轮，训练准确率: 0.9572833333333334 测试准确率: 0.9556\n",
      "两层感知机 第 7 轮，训练准确率: 0.9616833333333333 测试准确率: 0.9598\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两层感知机 第 8 轮，训练准确率: 0.9657333333333333 测试准确率: 0.9619\n",
      "两层感知机 第 9 轮，训练准确率: 0.9690666666666666 测试准确率: 0.964\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两层感知机 第 10 轮，训练准确率: 0.9720666666666666 测试准确率: 0.9663\n"
     ]
    }
   ],
   "source": [
    "# 两层感知机：加一个隐藏层用 ReLU 激活\n",
    "np.random.seed(0)\n",
    "hidden_size = 128\n",
    "W1 = (np.random.randn(input_dim, hidden_size) * 0.01).astype(np.float32)\n",
    "b1 = np.zeros(hidden_size, dtype=np.float32)\n",
    "W2 = (np.random.randn(hidden_size, num_classes) * 0.01).astype(np.float32)\n",
    "b2 = np.zeros(num_classes, dtype=np.float32)\n",
    "\n",
    "learning_rate = 0.1\n",
    "epochs = 10\n",
    "batch_size = 128\n",
    "\n",
    "two_train_history = []\n",
    "two_test_history = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    index_array = np.arange(train_images.shape[0])\n",
    "    np.random.shuffle(index_array)\n",
    "    for start in range(0, train_images.shape[0], batch_size):\n",
    "        batch_index = index_array[start:start + batch_size]\n",
    "        x_batch = train_images[batch_index]\n",
    "        y_batch = train_labels[batch_index]\n",
    "        hidden_linear = np.dot(x_batch, W1) + b1\n",
    "        hidden_activation = np.maximum(0, hidden_linear)\n",
    "        logits = np.dot(hidden_activation, W2) + b2\n",
    "        logits = logits - np.max(logits, axis=1, keepdims=True)\n",
    "        exp_logits = np.exp(logits)\n",
    "        probs = exp_logits / np.sum(exp_logits, axis=1, keepdims=True)\n",
    "        one_hot = np.zeros_like(probs)\n",
    "        one_hot[np.arange(one_hot.shape[0]), y_batch] = 1\n",
    "        grad_output = (probs - one_hot) / one_hot.shape[0]\n",
    "        grad_W2 = np.dot(hidden_activation.T, grad_output)\n",
    "        grad_b2 = grad_output.sum(axis=0)\n",
    "        grad_hidden = np.dot(grad_output, W2.T)\n",
    "        mask = hidden_linear > 0\n",
    "        grad_hidden = grad_hidden * mask\n",
    "        grad_W1 = np.dot(x_batch.T, grad_hidden)\n",
    "        grad_b1 = grad_hidden.sum(axis=0)\n",
    "        W2 = W2 - learning_rate * grad_W2\n",
    "        b2 = b2 - learning_rate * grad_b2\n",
    "        W1 = W1 - learning_rate * grad_W1\n",
    "        b1 = b1 - learning_rate * grad_b1\n",
    "    train_hidden = np.maximum(0, np.dot(train_images, W1) + b1)\n",
    "    train_logits = np.dot(train_hidden, W2) + b2\n",
    "    train_preds = np.argmax(train_logits, axis=1)\n",
    "    train_acc = (train_preds == train_labels).mean()\n",
    "    test_hidden = np.maximum(0, np.dot(test_images, W1) + b1)\n",
    "    test_logits = np.dot(test_hidden, W2) + b2\n",
    "    test_preds = np.argmax(test_logits, axis=1)\n",
    "    test_acc = (test_preds == test_labels).mean()\n",
    "    two_train_history.append(float(train_acc))\n",
    "    two_test_history.append(float(test_acc))\n",
    "    print(\"两层感知机 第\", epoch + 1, \"轮，训练准确率:\", float(train_acc), \"测试准确率:\", float(test_acc))\n",
    "\n",
    "two_train_acc = two_train_history[-1]\n",
    "two_test_acc = two_test_history[-1]\n",
    "two_test_preds = test_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7cad232c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:47.984901Z",
     "iopub.status.busy": "2025-11-03T08:18:47.984827Z",
     "iopub.status.idle": "2025-11-03T08:18:49.314279Z",
     "shell.execute_reply": "2025-11-03T08:18:49.314046Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 1 轮，训练准确率: 0.7433166666666666 测试准确率: 0.7589\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 2 轮，训练准确率: 0.8799833333333333 测试准确率: 0.8833\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 3 轮，训练准确率: 0.9246833333333333 测试准确率: 0.9263\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 4 轮，训练准确率: 0.94235 测试准确率: 0.9417\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 5 轮，训练准确率: 0.9490166666666666 测试准确率: 0.9451\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 6 轮，训练准确率: 0.9519166666666666 测试准确率: 0.9503\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 7 轮，训练准确率: 0.96665 测试准确率: 0.961\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 8 轮，训练准确率: 0.9711 测试准确率: 0.9655\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 9 轮，训练准确率: 0.9754 测试准确率: 0.9664\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三层感知机 第 10 轮，训练准确率: 0.9772166666666666 测试准确率: 0.9692\n"
     ]
    }
   ],
   "source": [
    "# 三层感知机：两个隐藏层\n",
    "np.random.seed(0)\n",
    "hidden_size1 = 128\n",
    "hidden_size2 = 64\n",
    "W1 = (np.random.randn(input_dim, hidden_size1) * 0.01).astype(np.float32)\n",
    "b1 = np.zeros(hidden_size1, dtype=np.float32)\n",
    "W2 = (np.random.randn(hidden_size1, hidden_size2) * 0.01).astype(np.float32)\n",
    "b2 = np.zeros(hidden_size2, dtype=np.float32)\n",
    "W3 = (np.random.randn(hidden_size2, num_classes) * 0.01).astype(np.float32)\n",
    "b3 = np.zeros(num_classes, dtype=np.float32)\n",
    "\n",
    "learning_rate = 0.1\n",
    "epochs = 10\n",
    "batch_size = 128\n",
    "\n",
    "three_train_history = []\n",
    "three_test_history = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    index_array = np.arange(train_images.shape[0])\n",
    "    np.random.shuffle(index_array)\n",
    "    for start in range(0, train_images.shape[0], batch_size):\n",
    "        batch_index = index_array[start:start + batch_size]\n",
    "        x_batch = train_images[batch_index]\n",
    "        y_batch = train_labels[batch_index]\n",
    "        hidden1_linear = np.dot(x_batch, W1) + b1\n",
    "        hidden1_activation = np.maximum(0, hidden1_linear)\n",
    "        hidden2_linear = np.dot(hidden1_activation, W2) + b2\n",
    "        hidden2_activation = np.maximum(0, hidden2_linear)\n",
    "        logits = np.dot(hidden2_activation, W3) + b3\n",
    "        logits = logits - np.max(logits, axis=1, keepdims=True)\n",
    "        exp_logits = np.exp(logits)\n",
    "        probs = exp_logits / np.sum(exp_logits, axis=1, keepdims=True)\n",
    "        one_hot = np.zeros_like(probs)\n",
    "        one_hot[np.arange(one_hot.shape[0]), y_batch] = 1\n",
    "        grad_output = (probs - one_hot) / one_hot.shape[0]\n",
    "        grad_W3 = np.dot(hidden2_activation.T, grad_output)\n",
    "        grad_b3 = grad_output.sum(axis=0)\n",
    "        grad_hidden2 = np.dot(grad_output, W3.T)\n",
    "        mask2 = hidden2_linear > 0\n",
    "        grad_hidden2 = grad_hidden2 * mask2\n",
    "        grad_W2 = np.dot(hidden1_activation.T, grad_hidden2)\n",
    "        grad_b2 = grad_hidden2.sum(axis=0)\n",
    "        grad_hidden1 = np.dot(grad_hidden2, W2.T)\n",
    "        mask1 = hidden1_linear > 0\n",
    "        grad_hidden1 = grad_hidden1 * mask1\n",
    "        grad_W1 = np.dot(x_batch.T, grad_hidden1)\n",
    "        grad_b1 = grad_hidden1.sum(axis=0)\n",
    "        W3 = W3 - learning_rate * grad_W3\n",
    "        b3 = b3 - learning_rate * grad_b3\n",
    "        W2 = W2 - learning_rate * grad_W2\n",
    "        b2 = b2 - learning_rate * grad_b2\n",
    "        W1 = W1 - learning_rate * grad_W1\n",
    "        b1 = b1 - learning_rate * grad_b1\n",
    "    train_hidden1 = np.maximum(0, np.dot(train_images, W1) + b1)\n",
    "    train_hidden2 = np.maximum(0, np.dot(train_hidden1, W2) + b2)\n",
    "    train_logits = np.dot(train_hidden2, W3) + b3\n",
    "    train_preds = np.argmax(train_logits, axis=1)\n",
    "    train_acc = (train_preds == train_labels).mean()\n",
    "    test_hidden1 = np.maximum(0, np.dot(test_images, W1) + b1)\n",
    "    test_hidden2 = np.maximum(0, np.dot(test_hidden1, W2) + b2)\n",
    "    test_logits = np.dot(test_hidden2, W3) + b3\n",
    "    test_preds = np.argmax(test_logits, axis=1)\n",
    "    test_acc = (test_preds == test_labels).mean()\n",
    "    three_train_history.append(float(train_acc))\n",
    "    three_test_history.append(float(test_acc))\n",
    "    print(\"三层感知机 第\", epoch + 1, \"轮，训练准确率:\", float(train_acc), \"测试准确率:\", float(test_acc))\n",
    "\n",
    "three_train_acc = three_train_history[-1]\n",
    "three_test_acc = three_test_history[-1]\n",
    "three_test_preds = test_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0524ff99",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:49.315513Z",
     "iopub.status.busy": "2025-11-03T08:18:49.315427Z",
     "iopub.status.idle": "2025-11-03T08:18:49.317350Z",
     "shell.execute_reply": "2025-11-03T08:18:49.317104Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "单层感知机 测试准确率: 0.9206\n",
      "两层感知机 测试准确率: 0.9663\n",
      "三层感知机 测试准确率: 0.9692\n"
     ]
    }
   ],
   "source": [
    "# 输出最终结果，方便对比\n",
    "print(\"单层感知机 测试准确率:\", linear_test_acc)\n",
    "print(\"两层感知机 测试准确率:\", two_test_acc)\n",
    "print(\"三层感知机 测试准确率:\", three_test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0cd5b7a0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-11-03T08:18:49.318315Z",
     "iopub.status.busy": "2025-11-03T08:18:49.318246Z",
     "iopub.status.idle": "2025-11-03T08:18:49.395277Z",
     "shell.execute_reply": "2025-11-03T08:18:49.395048Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 可视化不同层数模型在测试集上的准确率曲线\n",
    "plt.figure(figsize=(6, 4))\n",
    "epoch_axis = np.arange(1, len(single_test_history) + 1)\n",
    "plt.plot(epoch_axis, single_test_history, label='1-Layer')\n",
    "plt.plot(epoch_axis, two_test_history, label='2-Layer')\n",
    "plt.plot(epoch_axis, three_test_history, label='3-Layer')\n",
    "plt.title('Test Accuracy vs Epochs (Custom Framework)')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
